home *** CD-ROM | disk | FTP | other *** search
/ No Fragments Archive 12: Textmags & Docs / nf_archive_12.iso / MAGS / SOURCES / ATARI_SRC.ZIP / atari source / HDX_BACK / HDLFILE / DESKDIR.C < prev    next >
Encoding:
C/C++ Source or Header  |  2001-02-09  |  28.9 KB  |  1,412 lines
  1. /*    DESKDIR.C        7/31/89            Jian Ye    */
  2. /*    Fix the count operation    8/1/89            D.Mui    */
  3.  
  4. #include <portab.h>    
  5. #include <osbind.h>
  6. #include <mobdefs.h>
  7. #include <gemdefs.h>
  8. #include <window.h>
  9. #include <defines.h>
  10. #include <deskusa.h>
  11.  
  12.  
  13. /*
  14.  * "DMA" buffer structure for Fsfirst() and Fsnext().
  15.  */
  16. typedef struct {
  17.     char    d_glob[12];    /* GEMDOS wildcard string from Fsfirst */
  18.     char    d_mask;        /* Attribute mask from Fsfirst */
  19.     char    d_dirent[4];    /* Offset into directory, MSB first */
  20.     char    d_dirid[4];    /* Pointer to directory structure in GEM mem */
  21.     char    d_fattr;    /* File attributes */
  22.     long    d_tandd;    /* Time and date words */
  23.     long    d_fsize;    /* File size */
  24.     char     d_fname[14];    /* File name */
  25. } DMABUFFER;
  26.  
  27.  
  28. #define OK    1
  29. #define ERROR   -1
  30. #define FTOF    1
  31. #define FTOD    2
  32. #define DTOD    3
  33. #define FILELEN 12
  34.  
  35. OBJECT     *cpbox;            /* cp or rm or mv dialog box */
  36. OBJECT     *samename;        /* name conflict dialog box */
  37. char     *cntopen;        /* can't open file alert box */
  38. char    *cntcrtdr;        /* can't create directory alert box */
  39. char    *cntcrtfl;        /* can't create file alert box */
  40. char    *cntdelf;        /* can't delete file alert box */
  41. char    *cntdeld;        /* can't delete directory alert box */
  42. char    *wrerror;        /* write file error alert box */
  43. char    *rderror;        /* read file error alert box */
  44. char    *nomemory;        /* not sufficient memory alert box */
  45.  
  46. int  srclen, dstlen;    /* the size of source and target buffer */
  47. long numfiles = 0L;        /* the number of files show in the dialog box */
  48. long numdirs = 0L;        /* the number of directories */
  49. long tolsize = 0L;        /* the total size of all files in the path */
  50. int  srcbuf, dstbuf;    /* the size of source and target buffer be define */
  51. int     editdir;            /* the flag for the user edit the name conflict */
  52. char *fixsrc, *fixdst;    /* the source and target string pointer */
  53. long _stksize = 25000;    /* resize the stack size */
  54. char *getall = "*.*";
  55. char *bckslsh = "\\\0";
  56.  
  57. /* AES (windows and messages) related variables */
  58. int formw, formh, sx, sy, lx, ly;    /* dialogue box dimensions */
  59. int hdesk, wdesk;                    /* window X, Y, width, height */
  60.  
  61. char *filestr = "abcdefgh.abcb";    /* the buffer for the file */
  62. char *cptitle = " COPY FILE(S) ";    /* the title for the cp dialog box */
  63. char *mvtitle = " MOVE FILE(S) ";    /* the title for the mv dialog box */
  64. char *rmtitle = "DELETE FILE(S)";    /* the title for the rm dialog box */
  65.  
  66. extern int d_next();
  67.  
  68.  
  69. /*    Main entrance of the file operation function    */
  70.  
  71. dofiles(s, d, code, ndirs, nfiles, tsize)
  72.  
  73. char *s, *d;
  74. int code;
  75. long *ndirs, *nfiles, *tsize;
  76.  
  77. {
  78.     desk_wait( TRUE );
  79.  
  80.     if (getalladdr() != OK)    
  81.         goto cleanup;
  82.  
  83.     numdirs = *ndirs;
  84.     numfiles = *nfiles;
  85.     tolsize = *tsize;
  86.  
  87.     do
  88.     {
  89.        switch( code )
  90.        {
  91.          case OP_COUNT:
  92.         count(s);
  93.         break;
  94.         
  95.          case OP_COPY:
  96.         cpfile(getinfo(s, d, code));
  97.         break;
  98.  
  99.          case OP_DELETE:    
  100.         rmfile(getinfo(s, d, code));         
  101.         break;
  102.  
  103.          case OP_MOVE:
  104.         mvfile(getinfo(s, d, code));
  105.         break;
  106.     
  107.        }
  108.  
  109.     } while (d_next(&s));
  110.  
  111.     *ndirs = numdirs;
  112.     *nfiles = numfiles;
  113.     *tsize = tolsize;
  114.  
  115. cleanup:
  116.     desk_wait( FALSE );
  117.     return OK;
  118. }
  119.  
  120.  
  121. /* do the rm file job */
  122.  
  123. rmfile(flag)
  124. int flag;
  125. {
  126.     int ret;
  127.  
  128.     fixdst = fixsrc;
  129.  
  130.     if ( flag == FTOD )        /* one file from dir rm */     
  131.     {     
  132.        updatedir();
  133.        updatefile();
  134. redel:
  135.        if ( (ret = Fdelete(fixsrc)) )    
  136.        {
  137.           if ( (ret == 0xFFFA) || (ret == 0xFFFE) )    /* seek error or */
  138.         Pterm(1);                  /* drive not ready */
  139.  
  140.           if ( err(cntdelf) == 2 )        /* retry */    
  141.         goto redel;
  142.         }
  143.         else    
  144.           updatnfile();    
  145.     } 
  146.     else            /* rm dir or files    */     
  147.           dormfd();
  148.         /* delete the first folder from source */
  149.         deleted();
  150.  
  151. endrm:
  152.     erasemsg();
  153.     Mfree(fixsrc);
  154.     Mfree(fixdst);
  155.     return OK;
  156. }
  157.  
  158.  
  159. /* do the cp file job */
  160.  
  161. cpfile(flag)
  162.  
  163. int flag;
  164.  
  165. {
  166.     /*
  167.     if (showbox(cptitle) == CCANCEL)        {
  168.         goto endcp;
  169.     }
  170.     */
  171.     if (flag == DTOD)     {    /* files and directories cp */
  172.         docpfd();
  173.     } else {                /* a file cp */
  174.         updatedir();
  175.         updatefile();
  176.         wrfile(fixsrc, fixdst);
  177.     }
  178.  
  179. endcp:
  180.     erasemsg();
  181.     Mfree(fixsrc);
  182.     Mfree(fixdst);
  183.     return OK;
  184. }
  185.  
  186.  
  187.  
  188. /* do the mv file job */
  189.  
  190. mvfile(flag)
  191. int flag;
  192.  
  193. {
  194.  
  195.     /*
  196.     if (showbox(mvtitle) == CCANCEL)        {
  197.         goto endmv;
  198.     }
  199.     */
  200.     if (flag == DTOD)    {    /* files and directories mv */
  201.         domvfd();
  202.         deleted();            /* rm the first folder */
  203.     } else {                /* a file mv */
  204.         updatedir();
  205.         updatefile();
  206.         wrfile(fixsrc, fixdst);
  207.     remvdel:
  208.         if (Fdelete(fixsrc))    {
  209.             if (err(cntdelf) == 2)    {    /* retry */
  210.                 goto remvdel;
  211.             } else {                    /* quit */
  212.                 goto endmv;
  213.             }
  214.         }
  215.     }
  216.  
  217. endmv:
  218.     erasemsg();
  219.     Mfree(fixsrc);
  220.     Mfree(fixdst);
  221.     return OK;
  222. }
  223.  
  224.  
  225.  
  226.  
  227.  
  228. /* recursively rm dir or files form a given path */
  229.  
  230. dormfd()
  231.  
  232. {
  233.     char *saved;
  234.     extern char *strcat();
  235.     extern char *strcpy();
  236.     DMABUFFER dumb;
  237.     int ret;
  238.  
  239.     saved = (DMABUFFER *)Fgetdta();
  240.     Fsetdta(&dumb);
  241.     strcat(getall, fixsrc);
  242.     if (!Fsfirst(fixsrc, 0xFF))    {
  243.         do     {
  244.             if (dumb.d_fname[0] != '.')    {
  245.                 if (SUBDIR & dumb.d_fattr)    {
  246.                     chksrcbuf(FILELEN);        /* check buf size */
  247.                     addfile(fixsrc, dumb.d_fname);/* add a dir to the path */
  248.                     strcat(bckslsh, fixsrc);
  249.                     dormfd();                /* to the recursion */
  250.                     rmstarb(fixsrc);        /* rm the star and back slash */
  251.                     getlastpath(filestr, fixsrc); 
  252.                     unpack(filestr);
  253.                     strcpy(filestr,
  254.                             ((TEDINFO *)(cpbox[CPDIR].ob_spec))->te_ptext); 
  255.                     strcpy("_", ((TEDINFO *)(cpbox[CPFILE].ob_spec))->te_ptext);
  256.                     objc_draw(cpbox, CPFILE, MAX_DEPTH, 0, 0, wdesk, hdesk);
  257.                     objc_draw(cpbox, CPDIR, MAX_DEPTH, 0, 0, wdesk, hdesk);
  258.                     /* delete a dir from source */
  259.                 redeld:
  260.                     if (Ddelete(fixsrc))    {
  261.                         if ((ret = err(cntdeld)) == 2)    { /* retry */
  262.                             goto redeld;
  263.                         } else if (ret == 3)    {         /* abort */
  264.                             Pterm(1);
  265.                         }
  266.                     }
  267.                     backdir(fixsrc);        /* back one dir */
  268.                     updatndir();
  269.                     srclen -= FILELEN;        /* subtract the add lenth */
  270.  
  271.                 } else {
  272.                     chksrcbuf(FILELEN);        /* check buf size */
  273.                     addfile(fixsrc, dumb.d_fname);
  274.                     updatedir();
  275.                     /* update the file box */
  276.                     unpack(dumb.d_fname); 
  277.                     strcpy(dumb.d_fname,
  278.                             ((TEDINFO *)(cpbox[CPFILE].ob_spec))->te_ptext); 
  279.                     objc_draw(cpbox, CPFILE, MAX_DEPTH, 0, 0, wdesk, hdesk);
  280.                 redelf:
  281.                     if ((ret = Fdelete(fixsrc)))    {
  282.                         if ((ret == 0xFFFA) || (ret == 0xFFFE))    { 
  283.                             /* seek error or  drive not ready */
  284.                             Pterm(1);                              
  285.                         }
  286.                         if ((ret = err(cntdelf)) == 2)    {    /* retry */
  287.                             goto redelf;
  288.                         } else if (ret == 3)    {            /* abort */
  289.                             Pterm(1);
  290.                         }
  291.                     }
  292.                     updatnfile();
  293.                     backdir(fixsrc);
  294.                     srclen -= FILELEN;        /* subtract the add lenth */
  295.                 }
  296.             } 
  297.         } while (!Fsnext());
  298.     } else {
  299.         Pterm(1);
  300.     }
  301.     Fsetdta(saved);
  302.     return OK;
  303. }
  304.  
  305.  
  306.  
  307. /* recursively cp files and directories from the given path */
  308.  
  309.  
  310. docpfd()
  311.  
  312. {
  313.     char *saved;
  314.     extern char *strcat();
  315.     extern char *strcpy();
  316.     DMABUFFER dumb;
  317.     int ret, code;
  318.  
  319.     saved = (DMABUFFER *)Fgetdta();
  320.     Fsetdta(&dumb);
  321.     strcat(getall, fixsrc);
  322.     if (!Fsfirst(fixsrc, 0xFF))    {
  323.         do     {
  324.             if (dumb.d_fname[0] != '.')    {
  325.                 if (SUBDIR & dumb.d_fattr)    {
  326.                     chksrcbuf(FILELEN);        /* check buf size */
  327.                     addfile(fixsrc, dumb.d_fname);/* add a dir to the path */
  328.                     strcat(bckslsh, fixsrc);
  329.                     chkdstbuf(FILELEN);        /* check buf size */
  330.                     strcat(dumb.d_fname, fixdst);
  331.                     unpack(dumb.d_fname);
  332.                     strcpy(dumb.d_fname,
  333.                             ((TEDINFO *)(cpbox[CPDIR].ob_spec))->te_ptext);
  334.                     strcpy("_", ((TEDINFO *)(cpbox[CPFILE].ob_spec))->te_ptext);
  335.                     objc_draw(cpbox, CPFILE, MAX_DEPTH, 0, 0, wdesk, hdesk);
  336.                     objc_draw(cpbox, CPDIR, MAX_DEPTH, 0, 0, wdesk, hdesk);
  337.                     /* update check the dir existing or not */
  338.                     if ((code = chkdir(dumb.d_fname, cpbox)) == QUIT)    {
  339.                         Pterm(1);
  340.                     } else if (code == SKIP)    {
  341.                         /* update the number of dir */
  342.                         updatndir();
  343.                         backdir(fixsrc);
  344.                         backdir(fixdst);
  345.                         srclen -= FILELEN;        /* subtract the add lenth */
  346.                         dstlen -= FILELEN;        /* subtract the add lenth */
  347.                         continue;
  348.                     }
  349.  
  350.                     if ((editdir) || (code == OK))    {
  351.                     recreate:
  352.                         if (Dcreate(fixdst))    {
  353.                             if ((ret = err(cntcrtdr)) == 1)    {    /* skip */
  354.                                 backdir(fixsrc);
  355.                                 backdir(fixdst);
  356.                                 srclen -= FILELEN;    /* subtract the add lenth */
  357.                                 dstlen -= FILELEN;    /* subtract the add lenth */
  358.                                 /* update the number of dir */
  359.                                 updatndir();
  360.                                 continue;
  361.                             } else if (ret == 2)    {    /* retry */
  362.                                 goto recreate;
  363.                             } else     {                    /* quit */
  364.                                 Pterm(1);
  365.                             }
  366.                         }
  367.                     }
  368.                     /* update the number of dir */
  369.                     updatndir();
  370.                     strcat(bckslsh, fixdst);/* fixdst -> c:\d1\d2\ */
  371.                     docpfd();                /* do the recursion */
  372.                     backdir(fixsrc);        /* back one dir */
  373.                     backdir(fixdst);        /* back one dir */
  374.                     srclen -= FILELEN;        /* subtract the add lenth */
  375.                     dstlen -= FILELEN;        /* subtract the add lenth */
  376.  
  377.                 } else {
  378.                     chksrcbuf(FILELEN);        /* check buf size */
  379.                     addfile(fixsrc, dumb.d_fname);
  380.                     chkdstbuf(FILELEN);        /* check buf size */
  381.                     addfile(fixdst, dumb.d_fname);
  382.                     updatedir();             /* update the folder */
  383.                     /* update the file box */
  384.                     unpack(dumb.d_fname); 
  385.                     strcpy(dumb.d_fname,
  386.                             ((TEDINFO *)(cpbox[CPFILE].ob_spec))->te_ptext); 
  387.                     objc_draw(cpbox, CPFILE, MAX_DEPTH, 0, 0, wdesk, hdesk);
  388.                     wrfile(fixsrc, fixdst);    /* cp a file to the destination */
  389.                     backdir(fixsrc);        /* back one dir */
  390.                     backdir(fixdst);        /* back one dir */
  391.                     srclen -= FILELEN;        /* subtract the add lenth */
  392.                     dstlen -= FILELEN;        /* subtract the add lenth */
  393.                 }
  394.             } 
  395.         } while (!Fsnext());
  396.     } else {
  397.         Pterm(1);
  398.     }
  399.     Fsetdta(saved);
  400.     return OK;
  401. }
  402.  
  403.  
  404. /* recursively mv files or directoies from a given path */
  405.  
  406.  
  407. domvfd()
  408.  
  409.  
  410. {
  411.     char *saved;
  412.     extern char *strcat();
  413.     extern char *strcpy();
  414.     DMABUFFER dumb;
  415.     int ret, code;
  416.  
  417.     saved = (DMABUFFER *)Fgetdta();
  418.     Fsetdta(&dumb);
  419.     strcat(getall, fixsrc);
  420.     if (!Fsfirst(fixsrc, 0xFF))    {
  421.         do     {
  422.             if (dumb.d_fname[0] != '.')    {
  423.                 if (SUBDIR & dumb.d_fattr)    {
  424.                     chksrcbuf(FILELEN);        /* check buf size */
  425.                     addfile(fixsrc, dumb.d_fname); /* add a dir into the path */
  426.                     strcat(bckslsh, fixsrc);
  427.                     chkdstbuf(FILELEN);        /* check buf size */
  428.                     strcat(dumb.d_fname, fixdst);
  429.                     unpack(dumb.d_fname);
  430.                     strcpy(dumb.d_fname,
  431.                             ((TEDINFO *)(cpbox[CPDIR].ob_spec))->te_ptext);
  432.                     strcpy("_", ((TEDINFO *)(cpbox[CPFILE].ob_spec))->te_ptext);
  433.                     objc_draw(cpbox, CPFILE, MAX_DEPTH, 0, 0, wdesk, hdesk);
  434.                     objc_draw(cpbox, CPDIR, MAX_DEPTH, 0, 0, wdesk, hdesk);
  435.                     /* update check the dir existing or not */
  436.                     if ((code = chkdir(dumb.d_fname, cpbox)) == QUIT)    {
  437.                         Pterm(1);
  438.                     } else if (code == SKIP)    {
  439.                         backdir(fixsrc);
  440.                         backdir(fixdst);
  441.                         updatndir();
  442.                         srclen -= FILELEN;        /* subtract the add lenth */
  443.                         dstlen -= FILELEN;        /* subtract the add lenth */
  444.                         continue;
  445.                     }
  446.  
  447.                     if ((editdir) || (code == OK))    {
  448.                     recrtd:
  449.                         if (Dcreate(fixdst))    {
  450.                             if ((ret = err(cntcrtdr)) == 1)    {    /* skip */
  451.                                 backdir(fixsrc);
  452.                                 backdir(fixdst);
  453.                                 updatndir();
  454.                                 srclen -= FILELEN;    /* subtract the add lenth */
  455.                                 dstlen -= FILELEN;    /* subtract the add lenth */
  456.                                 continue;
  457.                             } else if (ret == 2)    {    /* retry */
  458.                                 goto recrtd;
  459.                             } else     {                    /* quit */
  460.                                 Pterm(1);
  461.                             }
  462.                         }
  463.                     }
  464.                     updatndir();
  465.                     strcat(bckslsh, fixdst);
  466.                     domvfd();                /* do the recursion */
  467.                     rmstarb(fixsrc);        /* after call, -> c:\d1\ */
  468.                 remvd:
  469.                     if (Ddelete(fixsrc))    { /* delete a dir */
  470.                         if ((ret = err(cntdeld)) == 2)    { /* retry */
  471.                             goto remvd;
  472.                         } else if (ret == 3)    {         /* abort */
  473.                             Pterm(1);
  474.                         }
  475.                     }
  476.                     backdir(fixsrc);        /* back one dir */
  477.                     backdir(fixdst);        /* back one dir */
  478.                     srclen -= FILELEN;        /* subtract the add lenth */
  479.                     dstlen -= FILELEN;        /* subtract the add lenth */
  480.  
  481.                 } else {
  482.                     chksrcbuf(FILELEN);        /* check buf size */
  483.                     addfile(fixsrc, dumb.d_fname);
  484.                     chkdstbuf(FILELEN);        /* check buf size */
  485.                     addfile(fixdst, dumb.d_fname);
  486.                     updatedir();
  487.                     /* update the file */
  488.                     unpack(dumb.d_fname); 
  489.                     strcpy(dumb.d_fname,
  490.                             ((TEDINFO *)(cpbox[CPFILE].ob_spec))->te_ptext); 
  491.                     objc_draw(cpbox, CPFILE, MAX_DEPTH, 0, 0, wdesk, hdesk);
  492.                     wrfile(fixsrc, fixdst);        /* cp one file to destination */
  493.                     /* rm the file from source */
  494.                 remvf:
  495.                     if (Fdelete(fixsrc))    {
  496.                         if ((ret = err(cntdelf)) == 2)    {    /* retry */
  497.                             goto remvf;
  498.                         } else if (ret == 3)    {            /* abort */
  499.                             Pterm(1);
  500.                         }
  501.                     }
  502.                     backdir(fixsrc);        /* back one dir */
  503.                     backdir(fixdst);        /* back one dir */
  504.                     srclen -= FILELEN;        /* subtract the add lenth */
  505.                     dstlen -= FILELEN;        /* subtract the add lenth */
  506.                 }
  507.             } 
  508.         } while (!Fsnext());
  509.     } else {
  510.         Pterm(1);
  511.     }
  512.     Fsetdta(saved);
  513.     return OK;
  514. }
  515.  
  516.  
  517. /* set the right drive and call the recursive routine to do the counting */
  518.  
  519.  
  520. count(s)
  521.  
  522. char *s;
  523.  
  524. {
  525.     char *buf, *tmp, *addr;
  526.     int drv;
  527.  
  528.     addr = buf = (char *)Malloc((long)sizeof(s));
  529.     strcpy(s, buf);
  530.  
  531.     tmp = buf;
  532.     drv = *buf;
  533.     if (drv >= 'a')    
  534.       drv -= 'a';
  535.     else
  536.       drv -= 'A';
  537.  
  538.     Dsetdrv(drv); 
  539.     while (*tmp)
  540.       tmp++;
  541.  
  542.     if (*(tmp-1) == '*')
  543.     {
  544.       *(tmp-4) = '\0';
  545.       while(*buf != '\\')
  546.         buf++;
  547.  
  548.       if ( Dsetpath(buf) )    
  549.         Pterm(1);
  550.  
  551.       countrec();
  552.     }
  553.     else
  554.       numfiles++;
  555.  
  556.     Mfree( addr );
  557.     return OK;
  558. }
  559.  
  560.  
  561. /* counte the file and directory recursivly */
  562.  
  563. countrec()
  564.  
  565.  
  566. {
  567.     char *saved;
  568.     DMABUFFER dumb;
  569.  
  570.     saved = (DMABUFFER *)Fgetdta();
  571.     Fsetdta(&dumb);
  572.  
  573.     if (!Fsfirst(".\\*.*", 0xFF))    
  574.     {
  575.       numdirs++;
  576.       do     
  577.       {
  578.         if (dumb.d_fname[0] != '.')    
  579.         {
  580.           if (SUBDIR & dumb.d_fattr)    
  581.           {                           /* setpath to one more down */
  582.         if (Dsetpath(dumb.d_fname))
  583.            Pterm(1);
  584.  
  585.         countrec();    /* to the recursion setpath to one back */
  586.         if (Dsetpath(".\\.."))
  587.                   Pterm(1);
  588.           }
  589.           else 
  590.           {
  591.         numfiles++;    /* add up the file count and size    */
  592.         tolsize += dumb.d_fsize;
  593.           }
  594.         } 
  595.           } while (!Fsnext());
  596.     }
  597.  
  598.     Fsetdta( saved );    /* reset the dta    */
  599.     return OK;
  600. }
  601.  
  602.  
  603. /* Copy the file from the s to d */
  604.  
  605. wrfile(s, d)
  606.  
  607. char *s, *d;
  608.  
  609. {
  610.     int code, ret, status;
  611.     int inhand;
  612.     int outhand;
  613.     DMABUFFER *mydta;
  614.     char *buffer, *saved;
  615.     long copysize;
  616.  
  617. open:
  618.  
  619.     if ((inhand = Fopen(s, 0)) < 0)    {
  620.         if ((inhand == 0xFFFA) || (inhand == 0xFFFE))    {/* seek error or */
  621.             Pterm(1);                                    /* drive not ready */
  622.         }
  623.         if ((ret = err(cntopen)) == 1)    {     /* skip */
  624.             return OK;
  625.         } else if (ret == 2)    {            /* retry */
  626.             goto open;
  627.         } else {                            /* abort */
  628.             Pterm(1);
  629.         }
  630.     }
  631.  
  632.     saved = (DMABUFFER *)Fgetdta();
  633.     Fsetdta(mydta=(DMABUFFER *)Malloc((long)sizeof(DMABUFFER)));
  634.  
  635.     if (Fsfirst(s, 0xF7))    {
  636.         if (err(rderror) == 1)    {     /* skip */
  637.             goto doup;
  638.         } else {                     /* abort */
  639.             Fclose(inhand);
  640.             Mfree(mydta);
  641.             Pterm(1);
  642.         }
  643.     }
  644.  
  645.     /* check the created file existing or not */
  646.     if ((code = chkfile(d, cpbox)) == QUIT)    {
  647.         Fclose(inhand);
  648.         Mfree(mydta);
  649.         Pterm(1);
  650.     } else if (code == SKIP)    {
  651.         goto doup;
  652.     }
  653.  
  654.     status = mydta->d_fattr & 7;
  655. create:
  656.  
  657.     if ((outhand = Fcreate(d, status)) < 0)    {
  658.         if ((ret = err(cntcrtfl)) == 1)    {    /* skip */
  659.             goto doup;
  660.         } else if (ret == 2)    {            /* retry */
  661.             goto create;
  662.         } else {                            /* abort */
  663.             Fclose(inhand);
  664.             Mfree(mydta);
  665.             Pterm(1);
  666.         }
  667.     }
  668.  
  669.     buffer = (char *)Malloc(8192L);
  670.     copysize = mydta->d_fsize;
  671.     while (copysize > 8192)    {
  672.         if (Fread(inhand, 8192L, buffer) < 0)    {
  673.             if (err(rderror) == 1)    {    /* skip */
  674.                 Fdelete(d);
  675.                 goto okup;
  676.             } else {                    /* abort */
  677.                 goto quitup;
  678.             }
  679.         }
  680.  
  681.         if ((status = Fwrite(outhand, 8192L, buffer)) < 0)    {
  682.             if (err(wrerror) == 1)    {    /* skip */
  683.                 Fdelete(d);
  684.                 goto okup;
  685.             } else {                    /* abort */
  686.                 goto quitup;
  687.             }
  688.         }
  689.         /* check if there are sufficent memory */
  690.         if (status != 8192)        { /* not sufficent memory ??*/
  691.             err(nomemory);
  692.             goto quitup;
  693.         }
  694.         copysize -= 8192;
  695.     }
  696.  
  697.     if (copysize > 0)    {
  698.         if (Fread(inhand, copysize, buffer) < 0)    {
  699.             if (err(rderror) == 1)    {        /* skip */
  700.                 Fdelete(d);
  701.                 goto okup;
  702.             } else {                        /* abort */
  703.                 goto quitup;
  704.             }
  705.         }
  706.  
  707.         if ((status = Fwrite(outhand, copysize, buffer)) < 0)    {
  708.             if (err(wrerror) == 1)    {    /* skip */
  709.                 Fdelete(d);
  710.                 goto okup;
  711.             } else {                    /* abort */
  712.                 goto quitup;
  713.             }
  714.         }
  715.         /* check if there are sufficent memory */
  716.         if (status != copysize)        {
  717.             /* update not sufficent memory ??*/
  718.             err(nomemory);
  719.             goto quitup;
  720.         }
  721.     }
  722.  
  723. okup:
  724.     Fclose(outhand);
  725.     Mfree(buffer);
  726.  
  727. doup:
  728.  
  729.     Fclose(inhand);
  730.     Mfree(mydta);
  731.     Fsetdta(saved);
  732.     updatnfile();
  733.     return(OK);
  734.  
  735. quitup:
  736.  
  737.     Fclose(inhand);
  738.     Fclose(outhand);
  739.     Fdelete(d);
  740.     Mfree(buffer);
  741.     Mfree(mydta);
  742.     Fsetdta(saved);
  743.     Pterm(1);
  744. }
  745.  
  746.  
  747. /* Copy s and d into fixsrc and fixdst. Also check it is one file
  748.    copy or files and directories copy */
  749.  
  750. getinfo(s, d, code)
  751.  
  752. char *s, *d;
  753. int code;
  754.  
  755. {
  756.  
  757.     int sdir=0, ddir=0;
  758.     char *ptrs, *ptrd;
  759.     extern char *strcat();
  760.  
  761.     ptrs = s;
  762.     ptrd = d;
  763.     srclen = strlen(s) + 5;     /* 1 for null and 4 for \*.* */
  764.     dstlen = strlen(d) + 17;     /* 1 for numll, 4 for \*.* and 13 for folder */
  765.     srcbuf = 500;
  766.     dstbuf = 500;
  767.     while (srclen > srcbuf)    {
  768.         srcbuf *= 2;
  769.     }
  770.     while (dstlen > dstbuf)    {
  771.         dstbuf *= 2;
  772.     }
  773.     fixsrc = (char *)Malloc((long)srcbuf);
  774.     fixdst = (char *)Malloc((long)dstbuf);
  775.     mystrcp(fixsrc, &ptrs);    /* ptrs -> c:\d1\*.* or c:\d1\f; */
  776.                             /*after ptrs->*.* or f */
  777.     if (*ptrs == '*')    {    /* source are dir */
  778.         sdir = 1;
  779.         getlastpath(filestr,fixsrc);
  780.     } 
  781.  
  782.     if (code)    {        /* do directories or files cp or mv */
  783.         mystrcp(fixdst, &ptrd);    /* ptrd -> c:\d1\*.* or c:\d1\f; */
  784.                                 /*after ptrd->*.* or f */
  785.         if (*ptrd == '*')    {    /* target are dir */
  786.             ddir = 1;
  787.         }
  788.         if ((sdir) && (ddir))    {                 /* dir to dir */
  789.             if (*filestr)    {                    /* folder cp */
  790.                 chkdstbuf(FILELEN);                /* check buf size */
  791.                 addfile(fixdst, filestr);        /* add the folder to dst */
  792.                 created(filestr);                /* create the 1st folder */
  793.                 strcat(bckslsh, fixdst);
  794.             }
  795.             return (DTOD);
  796.         } else if ((!sdir) && (!ddir))    {         /* file to file */
  797.             return (FTOF);
  798.         } else {                                /* one file to dir */
  799.             chkdstbuf(FILELEN);                    /* check buf size */
  800.             strcat(ptrs, fixdst);
  801.             return (FTOD);
  802.         }
  803.     } else     {                    /* else do directories or files rm */
  804.         if (sdir)    {
  805.             return(DTOD);
  806.         } else {
  807.             return(FTOD);
  808.         }
  809.     }
  810. }
  811.  
  812.  
  813. created(dir)
  814.  
  815. char *dir;
  816.  
  817. {
  818.     int code, ret;
  819.  
  820.     unpack(dir);
  821.     strcpy(dir, ((TEDINFO *)(cpbox[CPDIR].ob_spec))->te_ptext);
  822.     strcpy("_", ((TEDINFO *)(cpbox[CPFILE].ob_spec))->te_ptext);
  823.     objc_draw(cpbox, CPFILE, MAX_DEPTH, 0, 0, wdesk, hdesk);
  824.     objc_draw(cpbox, CPDIR, MAX_DEPTH, 0, 0, wdesk, hdesk);
  825.     /* update check the dir existing or not */
  826.     if ((code = chkdir(dir, cpbox)) == QUIT)    {
  827.         Pterm(1);
  828.     } 
  829.     if ((editdir) || (code == OK))    {
  830.         repeat:
  831.             if (Dcreate(fixdst))    {
  832.                 if ((ret = err(cntcrtdr)) == 2)    {    /* retry */
  833.                     goto repeat;
  834.                 } else if (ret == 3)    {    /* abort */
  835.                     Pterm(1);
  836.                 }
  837.             }
  838.     }
  839.     /* update the number of dir */
  840.     updatndir();
  841. }
  842.  
  843.  
  844. deleted()
  845.  
  846. {
  847.     domore:
  848.     rmstarb(fixsrc);        /* remove the back slash */
  849.     if (Ddelete(fixsrc))    {
  850.         if ((ret = err(cntdeld)) == 2)    { /* retry */
  851.             goto domore;
  852.         } else if (ret == 3)    {         /* abort */
  853.             Pterm(1);
  854.         }
  855.     }
  856.     updatndir();
  857. }
  858.  
  859.  
  860. /*  this call will copy the string inside the s to 
  861.  *     the fixs. For example,
  862.  *     if s -> c:\d1\d2\*.* or c:\d1\d2\f, after the call,
  863.  *    fixs -> \d1\d2\  or \d1\d2\f ; s -> *.* or f            */
  864.  
  865. mystrcp(fixs, s)
  866.  
  867. char *fixs;
  868. char **s;
  869.  
  870. {
  871.     char *ptr;
  872.  
  873.     ptr = *s;
  874.     while ((*ptr) && (*ptr != '*'))        {
  875.         *fixs++ = *ptr++;
  876.     }
  877.     *fixs = '\0';
  878.     if (*ptr == '*')        {
  879.         *s = ptr;
  880.     } else {
  881.         while (*ptr != '\\')    {
  882.             ptr--;
  883.         }
  884.         *s = ++ptr;
  885.     }
  886.  
  887. }
  888.  
  889.  
  890. /* check the size of source buffer */
  891.  
  892. chksrcbuf(addlen)
  893.  
  894. int addlen;
  895.  
  896. {
  897.  
  898.     char *ptr;
  899.  
  900.     if ((srclen + addlen) > srcbuf)        {
  901.         srcbuf *= 2;
  902.         ptr = fixsrc;
  903.         fixsrc = (char *)Malloc((long)srcbuf);
  904.         strcpy(ptr, fixsrc);
  905.         Mfree(ptr);
  906.     }
  907.     srclen += addlen;
  908. }
  909.  
  910.  
  911. /* check the size of target buffer */
  912.  
  913. chkdstbuf(addlen)
  914.  
  915. int addlen;
  916.  
  917. {
  918.  
  919.     char *ptr;
  920.  
  921.     if ((dstlen + addlen) > dstbuf)        {
  922.         dstbuf *= 2;
  923.         ptr = fixdst;
  924.         fixdst = (char *)Malloc((long)dstbuf);
  925.         strcpy(ptr, fixdst);
  926.         Mfree(ptr);
  927.     }
  928.     dstlen += addlen;
  929. }
  930.  
  931.  
  932. /* s -> c:\d1\d2\*.* or c:\d1\d2\, obj -> f; after the call
  933.  * s -> c:\d1\d2\f                            */
  934.  
  935. addfile(s, obj)
  936.  
  937. char *s, *obj;
  938.  
  939. {
  940.     char *ptr;
  941.     extern char *strcat();
  942.  
  943.     ptr = s;
  944.     while (*ptr)    {
  945.         ptr++;
  946.     }
  947.     if (*(ptr-1) == '*')    {
  948.         *(ptr-3) = '\0';
  949.     }
  950.     strcat(obj, s);
  951. }
  952.  
  953.  
  954.  
  955. /* src -> c:\d1\d2\*.* or -> c:\d3\d5\, after the call,
  956.  * src -> c:\d1\d2 or -> c:\d3\d5                        */
  957.  
  958. rmstarb(src)
  959.  
  960. char *src;
  961.  
  962. {
  963.  
  964.     char *ptr;
  965.  
  966.     ptr = src;
  967.     while (*ptr)        {
  968.         ptr++;
  969.     }
  970.     if (*(ptr-1) == '\\')    {    /* src -> c:\d3\d5\ */
  971.         *(ptr-1) = '\0';
  972.     } else {                    /* src -> c:\d3\d5\*.*  */
  973.         *(ptr-4) = '\0';
  974.     }
  975. }
  976.  
  977.  
  978.  
  979.  
  980. /* str -> c:\d1\d2\*.* or c:\d1\d2\ or c:\d2\d4; after the call,
  981.  * str -> c:\d1\*.* or c:\d1\  or c:\d2\        */
  982.  
  983. backdir(str)
  984.  
  985. char *str;
  986.  
  987. {
  988.     char *ptr;
  989.  
  990.     ptr = str;
  991.     while (*ptr)      {
  992.         ptr++;
  993.     }
  994.     if (*(ptr-1) == '*')    {        /* str -> c:\d1\d2\*.*    */
  995.         ptr -= 5;                    /* ptr -> 2 of c:\d1\d2 */
  996.         while (*ptr != '\\')    {
  997.             ptr--;
  998.         }
  999.         *ptr++;
  1000.         *ptr++ = '*';
  1001.         *ptr++ = '.';
  1002.         *ptr++ = '*';
  1003.         *ptr = '\0';
  1004.     } else if (*(ptr-1) == '\\')        {    /* str -> c:\d1\d2\ */
  1005.         ptr -= 2;
  1006.         while (*ptr != '\\')    {
  1007.             ptr--;
  1008.         }
  1009.         *(ptr + 1) = '\0';
  1010.     } else     {                    /* str -> c:\d1\d2  */
  1011.         while (*ptr != '\\')    {
  1012.             ptr--;
  1013.         }
  1014.         *(ptr + 1) = '\0';
  1015.     }
  1016. }
  1017.  
  1018.  
  1019.  
  1020.  
  1021. /* check the directory is exist or not */
  1022.  
  1023.  
  1024. chkdir(dir, prvobjtree)
  1025.  
  1026. char *dir;
  1027. OBJECT *prvobjtree;
  1028.  
  1029. {
  1030.  
  1031.     int ret, but, drv;
  1032.     char *buf;
  1033.  
  1034.     buf = fixdst;
  1035.     editdir = 0;
  1036.  
  1037.     drv = *buf;
  1038.     if (drv >= 'a')        {
  1039.         drv -= 'a';
  1040.     } else {
  1041.         drv -= 'A';
  1042.     }
  1043.     Dsetdrv(drv);
  1044.     buf += 2;                /* set buf -> \d1\x */
  1045.     if (!(ret = Dsetpath(buf)))    {    /* direcory exist */
  1046.         /* update name conflict box */
  1047.         strcpy(dir, ((TEDINFO *)(samename[FNAME].ob_spec))->te_ptext);
  1048.         strcpy(dir, ((TEDINFO *)(samename[EDFNAME].ob_spec))->te_ptext);
  1049.         samename[COPY].ob_state = NORMAL;
  1050.         samename[SKIP].ob_state = NORMAL;
  1051.         samename[QUIT].ob_state = NORMAL;
  1052.         graf_mouse(ARROW, 0x0L);
  1053.         dsplymsg(samename);
  1054.         switch((but = form_do(samename, 0)))    {
  1055.             case COPY:    
  1056.                     if (!strcmp(((TEDINFO *)
  1057.                                 (samename[EDFNAME].ob_spec))->te_ptext, dir)) {
  1058.                         strcpy(
  1059.                         ((TEDINFO *)(samename[EDFNAME].ob_spec))->te_ptext,dir);
  1060.                         strcpy(dir,
  1061.                                 ((TEDINFO *)(cpbox[CPDIR].ob_spec))->te_ptext);
  1062.                         dopack(dir);
  1063.                         /* user edit the new name */
  1064.                         changelast(fixdst, dir);
  1065.                         editdir = 1;
  1066.                     }
  1067.                         break;
  1068.             case SKIP:    break;
  1069.             case QUIT:    break;
  1070.         }
  1071.         graf_mouse(HOURGLASS, 0x0L);
  1072.         dsplymsg(prvobjtree);
  1073.         return but;
  1074.     } else if (ret == 0xFFDE)    { /* path not found */
  1075.         return OK;
  1076.     } else {
  1077.         Pterm(1);
  1078.     }
  1079.  
  1080. }
  1081.  
  1082.  
  1083.  
  1084.  
  1085. /* check the file is exist or not */
  1086.  
  1087. chkfile(d, prvobjtree)
  1088.  
  1089. char *d;
  1090. OBJECT *prvobjtree;
  1091.  
  1092. {
  1093.  
  1094.     int ret, but;
  1095.  
  1096.     if ((ret = Fopen(d, 0)) >= 0)    {    /* file exist */
  1097.         /* update name conflict box */
  1098.         getlastpath(filestr, d);
  1099.         unpack(filestr);
  1100.         strcpy(filestr, ((TEDINFO *)(samename[FNAME].ob_spec))->te_ptext);
  1101.         strcpy(filestr, ((TEDINFO *)(samename[EDFNAME].ob_spec))->te_ptext);
  1102.         samename[COPY].ob_state = NORMAL;
  1103.         samename[SKIP].ob_state = NORMAL;
  1104.         samename[QUIT].ob_state = NORMAL;
  1105.         graf_mouse(ARROW, 0x0L);
  1106.         dsplymsg(samename);
  1107.         switch((but = form_do(samename, 0)))    {
  1108.             case COPY:    
  1109.                     if (!strcmp(filestr, 
  1110.                         ((TEDINFO *)(samename[EDFNAME].ob_spec))->te_ptext)) {
  1111.                         /* user edit the new name */
  1112.                         strcpy(
  1113.                         ((TEDINFO *)(samename[EDFNAME].ob_spec))->te_ptext,
  1114.                                                                     filestr);
  1115.                         strcpy(filestr,
  1116.                             ((TEDINFO *)(cpbox[CPFILE].ob_spec))->te_ptext);
  1117.                         dopack(filestr);
  1118.                         changelast(d, filestr);
  1119.                     }
  1120.                         break;
  1121.             case SKIP:    break;
  1122.             case QUIT:    break;
  1123.         }
  1124.         graf_mouse(HOURGLASS, 0x0L);
  1125.         dsplymsg(prvobjtree);
  1126.         return but;
  1127.     } else if (ret == 0xFFDF)    {     /* file not found */
  1128.         return OK;
  1129.     } else {
  1130.         Pterm(1);
  1131.     }
  1132.  
  1133. }
  1134.  
  1135.  
  1136. /* if buf -> unpack.rsc, after the call, buf -> unpack  rsc.  */
  1137.  
  1138. unpack(buf)
  1139.  
  1140. char *buf;
  1141.  
  1142. {
  1143.     int i=0;
  1144.     char *ptr;
  1145.  
  1146.     ptr = buf;
  1147.     while ((*ptr != '.') && (*ptr))    {
  1148.         ptr++;
  1149.         i++;
  1150.     }
  1151.     if ((*ptr == '.') && (i != 8))    { /* src -> abcx.x */
  1152.         *(buf+11) = '\0';
  1153.         *(buf+10) = *(buf+i+3);
  1154.         *(buf+9) = *(buf+i+2);
  1155.         *(buf+8) = *(buf+i+1);
  1156.         for (; i < 8; i++)    {
  1157.             *(buf+i) = ' ';
  1158.         }
  1159.     } else if ((i == 8)    && (*ptr == '.'))     {    /* src -> abcdefgh.x */
  1160.         *(buf+8) = *(buf+9);
  1161.         *(buf+9) = *(buf+10);
  1162.         *(buf+10) = *(buf+11);
  1163.         *(buf+11) = '\0';
  1164.     }
  1165.  
  1166. }
  1167.  
  1168.  
  1169.  
  1170.  
  1171. /* src -> file    rsc, after the call;
  1172.    src -> file.rsc                        */
  1173.  
  1174. dopack(src)
  1175.  
  1176. char *src;
  1177.  
  1178. {
  1179.     char *ptr;
  1180.     int i=0;
  1181.  
  1182.     ptr = src;
  1183.     while ((*ptr != ' ') && (*ptr))    {
  1184.         ptr++;
  1185.         i++;
  1186.     }
  1187.     if (*ptr == ' ')    {
  1188.         *ptr++ = '.';
  1189.         *ptr++ = *(src+8);
  1190.         *ptr++ = *(src+9);
  1191.         *ptr++ = *(src+10);
  1192.         *ptr = '\0';
  1193.     } else if (i > 8)    {
  1194.         *(src+12) = '\0';
  1195.         *(src+11) = *(src+10);
  1196.         *(src+10) = *(src+9);
  1197.         *(src+9) = *(src+8);
  1198.         *(src+8) = '.';
  1199.     }
  1200. }
  1201.  
  1202.  
  1203. /* d -> c:\d1\d2\f1, name -> f2, after the call, d-> c:\d1\d2\f2     */
  1204.  
  1205. changelast(d, name)
  1206.  
  1207. char *d, *name;
  1208.  
  1209. {
  1210.     backdir(d);
  1211.     strcat(name, d);
  1212. }
  1213.  
  1214.  
  1215. /* src -> c:\d1\d2\ or c:\d1\ or c:\; or
  1216.    src -> c:\d1\d2\f or c:\d1\f or c:\f; after the call,
  1217.    buf -> d2 or d1 or c:\                                 */
  1218.  
  1219.  
  1220. getndlast(buf, src)
  1221.  
  1222. char *buf, *src;
  1223.  
  1224. {
  1225.     char *tmp;
  1226.  
  1227.     tmp = src;
  1228.     while (*tmp)    {
  1229.         tmp++;
  1230.     }
  1231.     tmp--;
  1232.     if (*tmp == '\\')    {    /* src -> c:\d1\d2\ or c:\d1\ or c:\ */
  1233.         if (*(tmp-1) == ':')    { /* src -> c:\ */
  1234.             *buf = '\0';
  1235.         } else {
  1236.             tmp--;
  1237.             while (*tmp != '\\')        {
  1238.                 tmp--;
  1239.             }
  1240.             tmp++;
  1241.             while ((*buf = *tmp++) != '\\')    {
  1242.                 buf++;
  1243.             }
  1244.             *buf = '\0';
  1245.         }
  1246.     } else {    /* src -> c:\d1\d2\f or c:\d1\f or c:\f */
  1247.         while (*tmp-- != '\\')        {
  1248.             ;
  1249.         }
  1250.         if (*tmp == ':')    { /* src -> c:\f */
  1251.             while ((*buf++ = *src++) != '\\')    {
  1252.                 ;
  1253.             }
  1254.             *buf = '\0';
  1255.         } else {    /* src -> c:\d1\d2\f or c:\d1\f */
  1256.             while (*tmp != '\\')        {
  1257.                 tmp--;
  1258.             }
  1259.             tmp++;
  1260.             while ((*buf = *tmp++) != '\\')    {
  1261.                 buf++;
  1262.             }
  1263.             *buf = '\0';
  1264.         }
  1265.     }
  1266. }
  1267.  
  1268.  
  1269.  
  1270. /* src -> c:\f or c:\d1\f or c:\f\, after the call,
  1271.    buf -> f. But if src ->c:\, then buf -> Null     */
  1272.  
  1273. getlastpath(buf, src)
  1274.  
  1275. char *buf, *src;
  1276.  
  1277. {
  1278.     char *tmp;
  1279.  
  1280.     tmp = src;
  1281.     while (*tmp)    {
  1282.         tmp++;
  1283.     }
  1284.     if (*(tmp-2) == ':')    {  /* src -> c:\ */
  1285.         buf = '\0';
  1286.         return OK;
  1287.     }
  1288.     if (*(tmp-1) == '\\')    {
  1289.         *(tmp-1) = '\0';
  1290.     }
  1291.     while (*tmp != '\\')    {    /* back one more path */
  1292.         tmp--;
  1293.     }
  1294.     tmp++;
  1295.     strcpy(tmp, buf);
  1296. }
  1297.  
  1298.  
  1299. /* up date the number of file in the dialog box */
  1300.  
  1301. updatnfile()
  1302.  
  1303. {
  1304.  
  1305.     lbintoas(--numfiles, ((TEDINFO *)(cpbox[NUMFILE].ob_spec))->te_ptext);
  1306.     objc_draw(cpbox, NUMFILE, MAX_DEPTH, 0, 0, wdesk, hdesk);
  1307. }
  1308.  
  1309. /* up date the number of directory in the dialog box */
  1310.  
  1311. updatndir()
  1312.  
  1313. {
  1314.  
  1315.     lbintoas(--numdirs, ((TEDINFO *)(cpbox[NUMDIR].ob_spec))->te_ptext);
  1316.     objc_draw(cpbox, NUMDIR, MAX_DEPTH, 0, 0, wdesk, hdesk);
  1317. }
  1318.  
  1319.  
  1320. /* up date the directory in the dialog box */
  1321.  
  1322.  
  1323. updatedir()
  1324.  
  1325. {
  1326.     getndlast(filestr, fixdst) ;
  1327.     unpack(filestr);
  1328.     strcpy(filestr, ((TEDINFO *)(cpbox[CPDIR].ob_spec))->te_ptext);
  1329.     objc_draw(cpbox, CPDIR, MAX_DEPTH, 0, 0, wdesk, hdesk);
  1330. }
  1331.  
  1332.  
  1333.  
  1334. /* up date the file in the dialog box */
  1335.  
  1336. updatefile()
  1337.  
  1338. {
  1339.     getlastpath(filestr, fixdst) ;
  1340.     unpack(filestr);
  1341.     strcpy(filestr, ((TEDINFO *)(cpbox[CPFILE].ob_spec))->te_ptext);
  1342.     objc_draw(cpbox, CPFILE, MAX_DEPTH, 0, 0, wdesk, hdesk);
  1343.  
  1344. }
  1345.  
  1346.  
  1347. /* get the dialog box string */
  1348.  
  1349. getalladdr()
  1350. {
  1351.  
  1352.     /* Error messages */
  1353.     if (!rsrc_gaddr(5, CNTOPEN, &cntopen)
  1354.         || !rsrc_gaddr(5, CNTCRTDR, &cntcrtdr)
  1355.         || !rsrc_gaddr(5, CNTCRTFL, &cntcrtfl)
  1356.         || !rsrc_gaddr(5, WRERROR, &wrerror)
  1357.         || !rsrc_gaddr(5, NOMEMORY, &nomemory)
  1358.         || !rsrc_gaddr(5, CNTDELF, &cntdelf)
  1359.         || !rsrc_gaddr(5, CNTDELD, &cntdeld)
  1360.         || !rsrc_gaddr(5, RDERROR, &rderror))
  1361.         return ERROR;
  1362.         
  1363.  
  1364.     if (!rsrc_gaddr(0, CPBOX, &cpbox)
  1365.         || !rsrc_gaddr(0, SAMENAME, &samename))    {
  1366.             return ERROR;
  1367.     }
  1368.     return OK;
  1369. }
  1370.  
  1371.  
  1372.  
  1373. /*
  1374.  *  Display a dialogue box on the screen.
  1375.  *    Input:
  1376.  *        tree - object tree for dialogue box to be displayed.
  1377.  *    Output:
  1378.  *        formw, formh, sx, sy, lx, ly - dimensions of box.
  1379.  */
  1380. dsplymsg(tree)
  1381. OBJECT *tree;
  1382. {
  1383.     form_center(tree,&lx, &ly, &formw, &formh);
  1384.     form_dial(1, 0, 0, 0, 0, lx, ly, formw, formh);
  1385.     objc_draw(tree, 0, MAX_DEPTH, 0, 0, wdesk, hdesk);
  1386. }
  1387.  
  1388.  
  1389. /*
  1390.  *  Erase a dialogue box from the screen.
  1391.  *    Input:
  1392.  *        formw, formh, sx, sy, lx, ly - dimensions of box.
  1393.  */
  1394. erasemsg()
  1395. {
  1396.     form_dial(3, 0, 0, 0, 0, lx, ly, formw, formh);
  1397. }
  1398.  
  1399.  
  1400.  
  1401.  
  1402. err(s)
  1403. char *s;
  1404. {
  1405.     int ret;
  1406.  
  1407.     graf_mouse(ARROW, 0x0L);
  1408.     ret = form_alert(1, s);
  1409.     graf_mouse(HOURGLASS, 0x0L);
  1410.     return (ret);
  1411. }
  1412.